CD Actual 1/PC Actual CD 01.iso/trucos/laborat/lab.cd

Text File | 1995-01-03 | 34.3 KB | 1,722 lines

LOS TRUCOS DEL LABORATORIO


PROGRAMAS PROFESIONALES

Los técnicos del Laboratorio de PC Actual evaluamos continuamente gran
cantidad de programas, entre los que se encuentran los realizados por
nuestros lectores. Por este motivo observamos ciertos detalles que
hacen que los programas de nuestros lectores no lleguen a tener ese
toque de profesionalidad tan deseable en toda aplicación.

Cualquiera que haya programado alguna vez en C o Pascal y haya
necesitado hacer uso de funciones gráficas, se habrá visto obligado a
incluir en el mismo directorio en que se encontraba el programa
definitivo los conocidos ficheros BGI (Borland Graphics Interface).
Esta no es, desde luego, una solución muy profesional, puesto que
cualquier descuido con estos BGI daría al traste con nuestro programa.

Uno de los detalles más sencillos de conseguir es la introducción de
dichos drivers de pantalla (.BGI) y de fuentes de letra (.CHR), dentro
de los ejecutables realizados con compiladores de Borland (Turbo
Pascal, Borland Pascal, Turbo C, etc).

El siguiente ejemplo muestra cómo introducir el driver para tarjetas
VGA (EgaVga.bgi) dentro de un ejecutable en programas de Pascal,
haciendo uso de la utilidad BINOBJ (que por defecto se encuentra en el
directorio «\tp\utils»), utilidad que convierte ficheros binarios en
código objeto. Para ello teclearemos:

BINOBJ egavga.bgi egavga egavga

Tras esto obtendremos un fichero «egavga.obj». Para utilizarlo
bastará con introducirlo dentro del programa en Pascal, para lo que
crearemos la siguiente unidad:

Unit tarjetas;

Interface

Procedure EgaVga;

Implementation

Procedure EgaVga;

External;

{$L EgaVga.OBJ}

End.

TEXR = En nuestro programa, en la declaración de unidades empleadas
(línea «USES»), tendremos que incluir entonces la unidad «tarjetas»
así definida. Para inicializar el modo gráfico procederemos de la
siguiente forma:

Procedure IniciaGraficos; {Inicia modo gráfico}

Var GD,GM :Integer;

Begin

If RegisterBGIDriver (@EgaVga) <0 Then Halt (1);

GD := VGA;

GM := VGAHi;

InitGraph(GD,GM,'');

If GraphResult <0 then Halt(1);

End;

Para incorporar los archivos de las fuentes (.chr) procederemos de
manera similar. Como podemos ver, esto tiene como ventaja que una vez
hayamos realizado la conversión a obj y tengamos la unidad «tarjetas»,
no será necesario volverlas a escribir, y prodremos usarlo en todos
nuestros programas.

Para llevar esto a cabo en los programas en Turbo C actuaremos de modo
similar, sabiendo que Borland incluye con sus compiladores de C la
utilidad «bgiobj», que nos permite transformar ficheros BGI y CHR (los
que contienen los tipos de letras) en ficheros OBJ, directamente
enlazables con nuestro programa. Para este paso tenemos que dar la
orden BGIOBJ «fichero» (donde «fichero» es cualquier archivo con
extensión BGI o CHR).

A continuación podemos incluir los ficheros objeto así generados en
alguna de las librerías (por ejemplo, en graphics.lib). Para ello
daremos la orden

TLIB graphics + «fichero objeto» + «fichero objeto» + ...

A la hora de montar el programa tenemos que indicarle al compilador
que vamos a emplear estos ficheros, para lo cual es necesario utilizar
las funciones «registerbgidriver()» y «registerbgifont()» en el
programa principal antes de hacer la llamada a «initgraph()». Estas
funciones usan como argumento un nombre simbólico definido en
graphics.h (EGAVGA_driver, ATT_driver, triplex_font, gothic_font,
etc).

Nota: Si no hemos añadido los ficheros objeto a la librería gráfica,
es necesario compilarlos con el programa fuente (o añadirlos en el
fichero de proyecto). Por ejemplo,

TCC «programa_fuente» GRAPHICS.LIB EGAVGA.OBJ TRIP.OBJ



PROGRAMACION DE LA VGA EN MODO 320x200x256 (I)

Compiladores como Turbo Pascal o Turbo C (o sus hermanos mayores
Borland Pascal y Borland C/C++) ofrecen unos drivers de los que ya
hemos hablado en numerosas ocasiones: los BGI (Borland Graphics
Interface).

Con estos drivers en modo VGA podemos conseguir la resolución de 640 x
480 con 16 colores, con la ventaja de tener un gran número de
funciones de dibujo y de salida de texto ya definidas. Este modo
ofrece excelentes resultados para programas que requieran gran
detalle, pero el problema surge cuando para nuestro objetivo
necesitamos mayor número de colores, pues 16 suelen ser pocos. En
este caso podemos recurrir al modo 320 x 200 con 256 colores.
Perdemos resolución, pero lo podemos subsanar mediante un buen uso de
la paleta de colores. En muchas ocasiones el cambio es preferible,
por lo que este modo es muy recomendable para ser utilizado en juegos.

La desventaja que posee este modo frente al VGA estándar ofrecido por
el driver BGI es que no disponemos de funciones de dibujo ni de salida
de texto, lo cual en principio puede asustar. Pero os aseguramos que
es más fácil de lo que parece, y desde estas líneas vamos a intentar
solventar todos los problemas que pueden aparecer.

También os recordamos que, aunque no se ofrezcan con los paquetes de
Borland, circulan por ahí gran cantidad de drivers BGI que sí soportan
este modo y los modos de SVGA (alcanzando incluso los 1.024 x 768 con
256 colores). Es fácil encontrarlos en cualquiera de las BBS
españolas (incluida por supuesto PC Actual BBS) con nombres tales como
SVGABGI, VGA256 u otros similares. Pero contemos o no contemos con
ellos podemos intentar acceder a la VGA a un nivel un poco más
profundo, para conseguir más potencia y velocidad.

En caso de disponer de los BGI para acceder al modo 320 x 200 x 256,
también conocido como modo 13h, simplemente inicializaremos como de
costumbre con el comando «initgraph» (tanto en C como en Pascal). Si
no disponemos de estos drivers o no necesitamos las funciones que nos
ofrecen, podemos inicializar el modo utilizando el assembler, cargando
el valor 13h en el registro ax, y llamando después a la interrupción
10. Por ejemplo, si estamos empleando Turbo Pascal podemos introducir
el siguiente conjunto de instrucciones en ensamblador:

asm

mov ax,13h

int 10h

end;

Si empleamos Turbo C o cualquiera de sus «hermanos», la sección de
código anterior queda como sigue:

asm {

mov ax,13h

int 10h

}

De esta forma, inicializaremos el modo 320 x 200 x 256. Una de las
ventajas que ofrece este modo es que, para acceder a cualquier
posición de memoria, sólo necesita un segmento de 64.000 bytes (320 x
200 x 1 byte de color por pixel). De esta forma, para iluminar el
pixel de coordenadas x e y sólo tendremos que cargar un byte en la
dirección de memoria A000h:y*320+x. Dicho byte corresponderá al valor
del color con que lo queramos iluminar, entre 0 y 255.

Por ejemplo, un simple programa en Pascal que dibuje 256 líneas
verticales, cada una de un color diferente, quedaría como sigue:

Program VGA;

Uses Crt;

Var x,y:integer;

Begin

 asm

 mov ax,13h

 int 10h

 end;

 For x:=0 to 255 do

 For y:= 0 to 199 do

 Mem[$A000:y*320+x]:=x;

 Repeat Until KeyPressed;

End.

La misma rutina en C nos quedaría como sigue:

# include <dos.h>

main ()

{

 int x, y;

 asm MOV AX, 0x13;

 asm INT 0x10;

 for (x = 0; x <= 255; x++)

 for (y = 0; y <= 199; y++)

 poke (0xA000, y*320 + x, x);

 getch();

}

Tras ejecutar cualquiera de los anteriores programas, cuando volvamos
al DOS nos encontraremos con que tenemos el modo de vídeo cambiado y
para volver al modo normal tendremos que ejecutar «mode co80». Para
evitar esto, podemos volver al modo de texto normal dentro del propio
programa. Para ello tenemos dos posibilidades: bien con la
instrucción «textmode (lastmode)» (común en C y Pascal, en C pertenece
a la librería conio.h y en Pascal a la unidad Crt) o bien usando de
nuevo el ensamblador, cargando un 3 en ax y ejecutando la interrupción
10h.

Por este mes terminamos con la programación de la VGA en el modo 13,
pero seguiremos en sucesivos números con este interesante tema. Y no
olvidéis que si vosotros tenéis alguna rutina interesante también
podéis mandarla y de paso conseguir algún que otro premio.



LA PROGRAMACION DE LA VGA 320x200x256 (II)

En el truco anterior iniciamos esta serie sobre la programación en uno
de los modos de la VGA más potentes y sencillos al mismo tiempo. La
posibilidad de usar 256 colores al mismo tiempo es algo que sobrepasa
con creces la pérdida de resolución frente a los 640x480 con 16
colores.

Por ello, vamos a seguir profundizando un poco más en el modo gráfico
más empleado, el conocido entre los programadores como modo 13. En el
número anterior explicamos la forma de inicializar la pantalla e
iluminar un pixel de un color determinado. Dijimos que para iluminar
el pixel de coordenadas x,y sólo hace falta cargar un byte en la
dirección de memoria A000h:y*320+x. Dicho byte corresponderá al valor
(de 0 a 255) del color empleado para iluminarlo. La forma más
sencilla de hacer esto en Pascal es mediante la instrucción
«Mem[$A000:y*320+x]:=c;», donde «c» es el color del que queremos
ilumninar la posición x,y.

También es posible hacerlo de forma inversa, es decir, escribir
«c:=Mem[$A000:y*320+x];». Con esta simple instrucción obtendremos el
color del pixel de coordenadas x,y. Con esto hemos conseguido simular
las instrucciones «PutPixel» y «GetPixel» proporcionadas con los
drivers BGI.

Como hemos dicho, lo mejor de este modo gráfico es la cantidad de
colores disponibles: tenemos en nuestra mano una paleta de 256
colores a elegir entre un total de 261.844 colores. Esto es debido a
que cada color lo podemos descomponer en diferentes intensidades de
los colores primarios rojo, verde y azul. Estas intensidades pueden
tomar valores del 0 al 63 para cada color primario, lo que nos da un
total de 64 x 64 x 64 combinaciones diferentes, que es igual a 261.844
colores. Por ejemplo, el rojo intenso tendra unos componentes de
color de 63 para el tono rojo y de 0 para los componentes verde y
azul.

Manipulando estos valores podemos conseguir la perfecta representación
de una imagen en pantalla, así como interesantes efectos entre los que
cabe destacar los fundidos, tan comunes en los juegos.

Pero ahora llega la gran pregunta, de qué forma se pueden leer y
modifcar los valores de la paleta. Pues es muy sencillo. Para leer
un valor de la paleta hay que introducir el número del color que
queremos leer en el puerto 3C7h, y después leer los valores de rojo,
verde y azul respectivamente del puerto 3C9h. En Turbo Pascal los
números en hexadecimal se introducen con un «$» delante, así el puerto
3C7h lo pondremos como $3c7, mientras que en «C» y «C++» los números
en hexadecimal se introducen con el prefijo «0x»: por ejemplo, el
mismo número lo escribiremos como 0x3C7.

Para que quede más claro, en Turbo Pascal tendremos un «procedure»
para leer el valor de un puerto, que quedará como sigue:

Procedure CogeColor(Color : Byte; Var R,V,A : Byte);

{ Lee las intensidades de Rojo, Verde y Azul de un Color }

Begin

 Port[$3c7] := Color;

 R := Port[$3c9];

 V := Port[$3c9];

 A := Port[$3c9];

End;

Ahora vamos a explicar el proceso contrario, es decir, la forma de
modificar las intensidades de rojo, verde y azul de un color
cualquiera. Para ello hay que introducir en el puerto 3C8h el número
del color a modificar y después introducir los valores de rojo, verde
y azul respectivamente en el puerto 3C9h. De nuevo la «procedure»
quedaría como sigue:

Procedure PonColor(Color : Byte; R,G,B : Byte);

{ Esto asigna a un Color las intensidades de Rojo, Verde y Azul }

Begin

 Port[$3c8] := Color;

 Port[$3c9] := R;

 Port[$3c9] := G;

 Port[$3c9] := B;

End;

En Turbo C empleamos el comando «inportb( int port )» para leer un
byte del puerto «port», mientras que para escribir a un puerto usamos
«outportb( int port, unsigned char byte )». Ambos comandos pertenecen
a la librería «dos.h».


PROGRAMACION DE LA VGA 320x200x256 (III)

Ha llegado la hora de poner en práctica algunos de los conocimientos
que os hemos venido dando en las dos primeras «lecciones» sobre la
VGA. Ya hemos aprendido a inicializar el modo gráfico 320x200x256, a
iluminar un punto o pixel con un determinado color y a modificar las
intensidades de rojo, verde y azul de cada uno de los 256 colores.

Vamos a realizar uno de los efectos más sencillos y a la vez más
llamativos, el conocido como fade o fundido. Este efecto habitual en
todo tipo de juegos consiste en pasar la imagen que tenemos en
pantalla de una forma suave a tener la pantalla totalmente negra (o
cualquier otro color). Y en el efecto contrario, pasar de una
pantalla negra a la imagen con todo su color.

Para efectuar los fundidos emplearemos los procedimientos «CogeColor»
y «PonColor» que ya explicamos anteriormente.

Procedure PonColor (Color:Byte; R,G,B:Byte);

Begin

 Port[$3c8]:=Color; Port[$3c9]:=R; Port[$3c9]:=G; Port[$3c9]:=B;

End;

Procedure CogeColor (Color:Byte; Var R,G,B:Byte);

Begin

 Port[$3c7]:=Color; R:=Port[$3c9]; G:=Port[$3c9]; B:=Port[$3c9];

End;

Es posible dejar la pantalla en negro si se ponen los componentes RGB
de todos los colores a 0. El procedimiento PonerNegro hace esto
mismo:

Procedure PonerNegro;

Var i:Integer;

Begin

 For i:=0 to 255 do

 PonColor (i,0,0,0);

End;

Para conseguir un buen efecto de fundido lo primero que debemos hacer
es grabar toda la paleta, para ello emplearemos un array:

Var Paleta := Array [0..255,1..3] of Byte;

Type Pal: Record

 Rojo, verde, Azul : byte;

 End;

Var Paleta : Array [0..255] Of Pal;

Los valores de 0 a 255 son para los 256 colores de que consta el modo
VGA que nos trata. Los valores 1 al 3 son para guardar las
intensidades de rojo, verde y azul. Para grabar todos los colores de
la paleta usaremos el siguiente procedimiento:

Procedure GrabaPaleta;

Var i: Integer;

Begin

 For i := 0 to 255 do

 CogeColor (Loop, Paleta [i,1], Paleta [i,2], Paleta [i,3]);

End;

Con esto conseguimos grabar la paleta entera en la variable Paleta.
Ahora podemos efectuar cualquier fundido sobre la pantalla. Para ello
podemos emplear el siguiente procedimiento, que efectúa un fundido de
la paleta actual a la que le indiquemos en la variable Paleta. Lo que
hace el programa es ir comparando los valores actuales de Paleta con
los de la paleta que queremos obtener; en caso de ser menores los
incrementa.

Procedure FadeToPal;

Var i,j: Integer;

 Tmp : Array [1..3] of byte;

 { Esta variable almacena temporalmente los valores de cada color }

Begin

 For i:=1 to 64 do Begin

 { Los valores de rojo, verde y azul para cada color toman valores
 del 0 al 63, por eso sólo necesitamos ejecutar el bucle un máximo
 de 64 veces}

 For j:=0 to 255 do Begin

 CogeColor (j,Tmp[1],Tmp[2],Tmp[3]);

 If Tmp[1]<Paleta[j,1] then inc (Tmp[1]);

 If Tmp[2]<Paleta[j,2] then inc (Tmp[2]);

 If Tmp[3]<Paleta[j,3] then inc (Tmp[3]);

 { Si las componentes de rojo, verde o azul de cada color «j» son
 menores del valor que debemos alcanzar las incrementamos en 1 }

 PonColor (j,Tmp[1],Tmp[2],Tmp[3]);

 { Fija los nuevos valores para los colores }

 End;

 End;

End;

Pero otro de los efectos clásicos es el fundido de una imagen hasta
alcanzar el negro. El efecto es el mismo pero al revés, así que lo
que tendremos que invertir es el interior del bucle para que si los
valores son mayores de 0, ir restando hasta alcanzar el 0.

Procedure FadeToNegro;

VAR i,j:integer;

 Tmp : Array [1..3] of byte;

 { Esta variable almacena temporalmente los valores de cada color }

BEGIN

 For i:=1 to 64 do Begin

 For j:=0 to 255 do Begin

 CogeColor (j,Tmp[1],Tmp[2],Tmp[3]);

 If Tmp[1]>0 then dec (Tmp[1]);

 If Tmp[2]>0 then dec (Tmp[2]);

 If Tmp[3]>0 then dec (Tmp[3]);

 { Si las componentes de rojo, verde o azul de cada color «j» son
 mayores que 0 les restamos 1, hasta que alcancen este valor }

 PonColor (j,Tmp[1],Tmp[2],Tmp[3]);

 { Fija los nuevos valores para los colores }

 End;

 End;

End;

Si vemos que los fundidos se realizan a gran velocidad podemos poner
un delay para que sean más lentos y logren un mayor efecto. Realizar
un fundido al negro de la pantalla es mucho más impresionante que
limpiar simplemente la pantalla. Para restaurar la paleta original
simplemente hay que poner de nuevo los valores de las componentes
rojo, verde y azul de cada uno de los 256 colores. Lo podemos
conseguir de la siguiente forma:

Procedure RestauraPaleta;

Var i:integer;

Begin

 For i:=0 to 255 do

 PonColor (i, Paleta[i,1], Paleta [i,2], Paleta [i,3]);

End;

A lo largo de la explicación hemos considerado la variable Paleta como
un array de 256x3 (256 colores x 3 componentes). Otra forma de
tratar la paleta puede ser definiendo:

Type Pal: Record

 Rojo, Verde, Azul : Byte;

 End;

Var Paleta : Array [0..255] Of Pal;

De esta forma en vez de referirnos a Paleta [i,1], Paleta [i,2] y
Paleta [i,3] pondremos Paleta[i].Rojo, Paleta[i].Verde y Paleta
[i].Azul, con lo cual evidentemente ganamos en claridad y comodidad.



MEJORAR LA PRESENTACION

Para mejorar la presentación de muchos programas, en especial los
juegos, es conveniente adaptarlos a la velocidad del procesador,
aunque antes deberemos saber qué procesador tiene instalado la máquina
sobre la que funcionará el programa.

Entre los programadores del Laboratorio Técnico hemos elgido la rutina
que os adjuntamos por su facilidad de uso e implementación en
diferentes lenguajes. Aquí damos un ejemplo de cómo hacerlo en Turbo
Pascal.

El bloque principal es el siguiente programa en ensamblador, que
grabaremos como «chiptype.asm»:

 CODE SEGMENT BYTE PUBLIC 'CODE'

 ASSUME CS:CODE

 PUBLIC chiptype

chiptype PROC FAR

control EQU WORD PTR [bp-2]

 push BP

 mov BP,SP

 push DI

 push SI

 push CX

 call cpu_type

 cmp DX,484

 jnz Not_486

 mov AX,DX

 jmp short Got_486

Not_486:

 call ndp_type

 add AX,DX


Got_486:

 pop CX

 pop SI

 pop DI

 pop BP

 ret

chiptype endp

cpu_type PROC NEAR

 pushf

 xor DX,DX

 xor AX,AX

 push AX

 popf

 pushf

 pop AX

 and AX, 0f000h

 cmp AX, 0f000h

 jz dig

 mov AX, 07000h

 push AX

 popf

 pushf

 pop AX

 and AX,07000h

 jnz got386

 mov DX, 0280

 jmp SHORT CPUbye

got386:

 .386

 mov edx,esp

 and esp, not 3

 pushfd

 pop eax

 mov ecx,eax

 xor eax,40000h

 push eax

 popfd

 pushfd

 pop eax

 xor eax,ecx

 shr eax,18

 push ecx

 popfd

 mov esp,edx

 and eax,1

 .8086

 jz SHORT CPU386

 mov DX,484

 jmp SHORT CPUbye

CPU386:

 mov DX,380

 jmp SHORT CPUbye

dig: mov AX, 0ffffh

 mov CL, 33

 shl AX, CL

 jz digmor

 mov DX,0180

 jmp SHORT CPUbye

digmor: xor AL,AL

 mov AL,40h

 mul AL

 jz gotNEC

 mov DX,0080

 jmp SHORT CPUbye

gotNEC: mov DX,0200

CPUbye: popf

 ret

cpu_type endp

ndp_type PROC NEAR

do_we: fninit

 mov byte ptr control+1,0

 fnstcw control

 mov AH,byte ptr [control+1]

 cmp AH,03h

 je chk_87

 xor AX,AX

 jmp SHORT NDPbye

chk_87: and control,NOT 0080h

 fldcw control

 fdisi

 fstcw control

 test control,0080h

 jz chk287

 mov AX,0001

 jmp SHORT NDPbye

chk287: finit

 fld1

 fldz

 fdiv

 fld st

 fchs

 fcompp

 fstsw control

 fwait

 mov AX,control

 sahf

 jnz got387

 mov AX,0002

 jmp SHORT NDPbye

got387: mov AX,0003

NDPbye: ret


ndp_type endp

CODE ends

 end

Una vez copiado lo ensamblamos con la orden «Tasm chiptype.asm», lo
que nos generará el codigo objeto de este programa. Incluye la
función «Chiptype» que devuelve un valor entero dependiendo del
procesador sobre el que corra el programa: mayor que 480 si es un
486, entre 380 y 480 si es un 386, si es un 286 nos da valores entre
280 y 380, mientra que si el valor devuelto es menor que 280 el
procesador sera un 808x ó 8018x. Para comprobar si existe
coprocesador instalado basta con hallar el valor de «ChipType» en
módulo 10 y comprobar que es distinto de 0.

Para implementar esta rutina en Turbo Pascal basta con escribir el
siguiente programa, que nos creará una «unidad» que podremos emplear
desde el programa principal.

{$R-,S-,I-,D+,F-,V-,B-,N-,L+ }

UNIT Chips;

INTERFACE

function ChipType : integer;

IMPLEMENTATION

{$L ChipType.obj }

function ChipType; external;

END.

Este es el programa principal, el cual nos devuelve el
procesador con el que estamos trabajando:


PROGRAM cpucheck;

USES

 Chips;

var

 Chip_Value : integer;

BEGIN

 Chip_Value := ChipType;

 if Chip_Value > 480 then

 Write ( 'El procesador es un 486' )

 else

 if Chip_Value > 380 then

 Write ( 'El procesador es un 386' )

 else

 if Chip_Value > 280 then

 Write ( 'El procesador es un 286' )

 else

 Write ( 'El procesador es un 808x o 8018x' );

 if Chip_Value > 480 then

 Writeln

 else

 if Chip_Value mod 10 <> 0 then

 Writeln ( ' Con Coprocesador' )

 else

 Writeln;

END.



EL ICONO DEL RATON

Entre las consultas que más suelen llegar a nuestra redacción se
encuentran las referentes a la programación del ratón. Una de las
dudas más comunes se refiere a la manera de modificar el icono del
mismo. Mediante esta sencilla rutina en ensamblador se puede
modificar la clásica flecha por cualquier otro dibujo. El único
límite está en que éste deberá tener un tamaño de 16x16 pixels y sólo
podrá tener un color.

Con el fin de facilitar su implementación, hemos incluido el código
ensamblador dentro del siguiente procedimiento, realizado en Turbo
Pascal.

procedure MiNuevoCursor; assembler;

asm

 jmp @1

 dw 1111111111111111b { máscara de pantalla : }

 dw 1111111111111111b { los 1's son pixels que }

 dw 1111100000001111b { "transparentan", los 0's }

 dw 1111100000001111b { son pixels donde el cursor }

 dw 1111000111000111b { es opaco. }

 dw 1100000111000001b

 dw 1100001111100001b

 dw 1100111111111001b

 dw 1100111111111001b

 dw 1100001111100001b

 dw 1100000111000001b

 dw 1111000111000111b

 dw 1111100000001111b

 dw 1111100000001111b

 dw 1111111111111111b

 dw 1111111111111111b


 dw 0000000000000000b { máscara de cursor: }

 dw 0000000000000000b { los 1's son pixels que }

 dw 0000011111110000b { se encienden para dibujar }

 dw 0000011111110000b { el cursor. }

 dw 0000111000110000b

 dw 0011111000111110b

 dw 0011110000011110b

 dw 0011000000000110b

 dw 0011000000000110b

 dw 0011110000011110b

 dw 0011111000111110b

 dw 0000111000111000b

 dw 0000011111110000b

 dw 0000011111110000b

 dw 0000000000000000b

 dw 0000000000000000b


@1:

 mov ax, cs

 mov es, ax

 mov dx, offset MiCursor+2

 mov ax, $0009

 mov bx,8 { coordenada x de control }

 mov cx,8 { coordenada y de control }

 int $33

end;

Como se puede observar, necesitamos dos máscaras (todos los conjuntos
de unos y ceros que representan el icono), ambas de 16x16. En la
«máscara de pantalla» los unos (1) representan los pixels que quedan
trasparentes mientras que los ceros (0) son los pixele donde el cursor
queda opaco. La segunda máscara es la «máscara del cursor», en la que
todo ocurre al revés que en la anterior; es decir, basta con sustituir
los unos por ceros y los ceros por unos, para conseguir esta segunda
máscara. En esta, los unos son los pixels que se encienden para
dibujar el icono, mientras que los ceros representan las zonas
traparentes.

También habrá que tener en cuenta las coordenadas del punto de
control, es decir, el punto sobre el que se dan las coordenadas del
ratón. Si tenemos una flecha, el punto de control será la punta de la
misma. En el ejemplo presentado, una especie de círculo, el punto de
control se situa en el centro del círculo.



IDENTIFICAR EL PROCESADOR

Para mejorar la presentación de muchos programas, en especial los
juegos, es conveniente adaptar el programa a la velocidad del
procesador, pero para ello debemos saber qué chip tiene instalado la
máquina sobre la que funcionará el programa. Hace dos meses, en la
sección de «Microconsultas» ya indicamos una rutina en ensamblador que
servía para estos menesteres.

Pero como dicha rutina podía resultar difícil de implementar en
nuestras aplicaciones, entre los programadores del Laboratorio Técnico
hemos elegido la siguiente rutina. Sus características fundamentales
son su facilidad de uso e implementación en diferentes lenguajes.
Aquí vamos a daros un ejemplo de cómo hacerlo en Turbo Pascal.

El bloque principal es el siguiente programa en ensamblador, que
grabaremos como «chiptype.asm»:

CODE SEGMENT BYTE PUBLIC 'CODE'

 ASSUME CS:CODE

 PUBLIC chiptype

chiptype PROC FAR

control EQU WORD PTR [bp-2]

 push BP

 mov BP,SP

 push DI

 push SI

 push CX

 call cpu_type

 cmp DX,484

 jnz Not_486

 mov AX,DX

 jmp short Got_486

Not_486:

 call ndp_type

 add AX,DX


Got_486:

 pop CX

 pop SI

 pop DI

 pop BP

 ret

chiptype endp

cpu_type PROC NEAR

 pushf

 xor DX,DX

 xor AX,AX

 push AX

 popf

 pushf

 pop AX

 and AX, 0f000h

 cmp AX, 0f000h

 jz dig

 mov AX, 07000h

 push AX

 popf

 pushf

 pop AX

 and AX,07000h

 jnz got386

 mov DX, 0280

 jmp SHORT CPUbye

got386:

 .386

 mov edx,esp

 and esp, not 3

 pushfd

 pop eax

 mov ecx,eax

 xor eax,40000h

 push eax

 popfd

 pushfd

 pop eax

 xor eax,ecx

 shr eax,18

 push ecx

 popfd

 mov esp,edx

 and eax,1

 .8086

 jz SHORT CPU386

 mov DX,484

 jmp SHORT CPUbye

CPU386:

 mov DX,380

 jmp SHORT CPUbye

dig: mov AX, 0ffffh

 mov CL, 33

 shl AX, CL

 jz digmor

 mov DX,0180

 jmp SHORT CPUbye

digmor: xor AL,AL

 mov AL,40h

 mul AL

 jz gotNEC

 mov DX,0080

 jmp SHORT CPUbye

gotNEC: mov DX,0200

CPUbye: popf

 ret

cpu_type endp

ndp_type PROC NEAR

do_we: fninit

 mov byte ptr control+1,0

 fnstcw control

 mov AH,byte ptr [control+1]

 cmp AH,03h

 je chk_87

 xor AX,AX

 jmp SHORT NDPbye

chk_87: and control,NOT 0080h

 fldcw control

 fdisi

 fstcw control

 test control,0080h

 jz chk287

 mov AX,0001

 jmp SHORT NDPbye

chk287: finit

 fld1

 fldz

 fdiv

 fld st

 fchs

 fcompp

 fstsw control

 fwait

 mov AX,control

 sahf

 jnz got387

 mov AX,0002

 jmp SHORT NDPbye

got387: mov AX,0003

NDPbye: ret


ndp_type endp

CODE ends

 end

Una vez copiado, lo ensamblaremos con la orden «tasm chiptype.asm», lo
que nos generará el codigo objeto. Este programa incluye la función
«Chiptype», que devuelve un valor entero dependiendo del procesador
sobre el que corra: si es un 486 devuelve un valor mayor que 480; si
es un 386 devuelve un valor entre 380 y 480; si es un 286 nos da
valores entre 280 y 380; mientras que si el valor devuelto es menor
que 280, el procesador sera un 808x o 8018x. Para comprobar si existe
coprocesador instalado basta con hallar el valor de «ChipType» en
módulo 10 y comprobar que es distinto de 0.

Para implementar esta rutina en Turbo Pascal basta con escribir la
siguiente rutina, que nos creará una unidad para ser usada desde el
programa principal y de esta forma simplificar el proceso.

{$R-,S-,I-,D+,F-,V-,B-,N-,L+ }

UNIT Chips;

INTERFACE

function ChipType : integer;

IMPLEMENTATION

{$L ChipType.obj }

function ChipType; external;

END.

Este es el programa principal, el cual nos devuelve el
procesador sobre el que está funcionando nuestra particular
aplicación:

PROGRAM cpucheck;

USES

 Chips;

var

 Chip_Value : integer;

BEGIN

 Chip_Value := ChipType;

 if Chip_Value > 480 then

 Write ( 'El procesador es un 80486' )

 else

 if Chip_Value > 380 then

 Write ( 'El procesador es un 80386' )

 else

 if Chip_Value > 280 then

 Write ( 'El procesador es un 80286' )

 else

 Write ( 'El procesador es un 808x o 8018x' );

 if Chip_Value > 480 then

 Writeln

 else

 if Chip_Value mod 10 <> 0 then

 Writeln ( ' Con Coprocesador' )

 else

 Writeln;

END.


PARAMETROS DE DISCOS DUROS

Muchos usuarios tras un borrado accidental de los datos de la BIOS, o
cualquier circunstancia similar, pierden todo el acceso a su disco
duro. En estos casos sólo es posible recuperar los datos de nuestro
disco si conseguimos reconfigurar correctamente los parámetros que
deben ir en la BIOS. El problema surge cuando no tenemos apuntados
dichos valores, precaución que deberíamos tomar siempre que
comprásemos un disco duro. Y probar una a una todas las combinaciones
posibles de cilindros, cabezas y sectores puede resultar una labor
imposible. Además, ya se sabe que los problemas sólo surgen cuando no
pueden ser solucionados.

El siguiente programita, escrito en C, nos dará todos los datos de
nuestro disco duro, proporcionando tanto cilindros como cabezas y
sectores, dando tanto los que lee de la BIOS como los que lee del
propio disco duro.

#define _PCACTUAL_

#include <stdlib.h>

#include <dos.h>

#include <stdio.h>

#include <conio.h>

#include <bios.h>

char *getascii (unsigned int in_data [], int off_start, int off_end);

void main (void)

{

 unsigned int dd [256];

 unsigned int dd_off;

 unsigned int loop;

 int num_drv; /* Numero de discos duros */

 union REGS registers;

 unsigned int bios_cyl [2], bios_head [2], bios_sec [2];

 /* Cilindros, Cabezas, Sectores */

 clrscr ();

 /* Cuantos discos y parámetros */

 num_drv = peekb (0x40, 0x75);

 /* area de datos de la BIOS, Numero de discos duros */

 /* Byte en el segmento 40H Offset 75H */

 for (loop = 0; loop < num_drv; loop++)

 /* Buscar a través de los discos */

 {

 /* Coger información del disco IDE */

 while (inp (0x1F7) != 0x50);

 /* Espera a que la controladora no esté ocupada */

 outp (0x1F6, (loop == 0 ? 0xA0 : 0xB0));

 /* Coger primer/segundo disco */

 outp (0x1F7, 0xEC);

 /* Coger información del disco */

 while (inp (0x1F7) != 0x58);

 /* Esperar a que esté listo para datos */

 for (dd_off = 0; dd_off != 256; dd_off++) /* Leer "sector" */

 dd [dd_off] = inpw (0x1F0);

 /* Coger información del disco de la BIOS */

 registers.h.ah = 0x8;

 /* Coger información del disco */

 registers.h.dl = 0x80 + loop;

 /* Disco es 80H para el disco 0, 81H para el 1 */

 int86 (0x13, ®isters, ®isters);

 if (! registers.x.cflag)

 {

 bios_head [loop] = registers.h.dh + 1;

 /* Las cabezas desde el 0 */

 bios_sec [loop] = registers.h.cl & 0x3F;

 /* sectores es bits 5 - 0 */

 bios_cyl [loop] = ((registers.h.cl & 0xC0) << 2) +
 registers.h.ch + 2;

 }

 clrscr ();

 fprintf (stdout, "DISCO %d:\n", loop);

 fprintf (stdout, "Número de modelo__________: %s\n", getascii (dd, 27, 46));

 fprintf (stdout, "Número de serie___________: %s\n", getascii (dd, 10, 19));

 fprintf (stdout, "Resultados del disco duro\n");

 fprintf (stdout, "Numero de cilindros (Fijado)______: %6u\n", dd [1]);

 fprintf (stdout, "Numero de cabezas_________________: %6u\n", dd [3]);

 fprintf (stdout, "Numero de sectores por pista______: %6u\n\n", dd [6]);

 fprintf (stdout, "Resultados de la BIOS\n");

 fprintf (stdout, "Numero de cilindros____________: %6u\n", bios_cyl [loop]);

 fprintf (stdout, "Numero de cabezas_____________: %6u\n", bios_head [loop]);

 fprintf (stdout, "Numero de sectores por pista__: %6u\n\n", bios_sec [loop]);

 if (! loop)

 {

 fprintf (stdout, "Pulsa una tecla");

 getch ();

 }

 }

}

char *getascii (unsigned int in_data [], int off_start, int off_end)

{

 static char ret_val [255];

 int loop, loop1;

 for (loop = off_start, loop1 = 0; loop <= off_end; loop++)

 {

 ret_val [loop1++] = (char) (in_data [loop] / 256); /* Coge el byte alto */

 ret_val [loop1++] = (char) (in_data [loop] % 256); /* Coge el byte bajo */

 }

 ret_val [loop1] = '\0';

 /* Nos aseguramos de que termina en carácter nulo */

 return (ret_val);

}


«SHELLS» LIMPIOS

Cuando escribimos un programa que efectúa llamadas externas a otras
aplicaciones necesitamos usar la función «Exec(Nombre_de_programa,
Linea_de_comandos». Esto funciona perfectamente, pero nos podemos
encontrar con un grave incoveniente: la salida se redirecciona a la
pantalla, escribiendo mensajes que en ocasiones no deseamos que se
vean. Un ejemplo lo encontramos cuando descomprimimos un programa,
llamamos al descompresor con «Exec» y en pantalla se nos muestra toda
la información del proceso de descompresión.

En estas ocasiones quedaría más elegante presentar en pantalla un
mensaje como «Trabajando...», «Instalando...» o algo similar.
Podremos conseguir este aspecto, sin duda mucho más profesional,
mediante el uso de la siguiente unidad, escrita en Turbo Pascal (como
se hace uso del ensamblador incorporado es necesario la versión 6.0 ó
superior). A pesar de estar escrita en Turbo Pascal, los usuarios del
lenguaje C, no encontrarán excesivas dificultades para adaptarla a sus
necesidades.

unit Mejora_Exec;

interface

Uses Dos;

function SetOutput(Nombre_Fichero: PathStr): Boolean;

procedure CancelOutput;

implementation

const OutRedir: Boolean = False;

function SetOutput(Nombre_Fichero: PathStr): Boolean;

begin

 Nombre_Fichero:=Nombre_Fichero+#0;

 SetOutput:=False;

 asm

 push ds

 mov ax, ss

 mov ds, ax

 lea dx, Nombre_Fichero[1]

 mov ah, 3Ch

 int 21h

 pop ds

 jnc @@1

 ret

@@1:

 push ax

 mov bx, ax

 mov cx, Output.FileRec.Handle

 mov ah, 46h

 int 21h

 mov ah, 3Eh

 pop bx

 jnc @@2

 ret

@@2:

 int 21h

 end;

 OutRedir:=True;

 SetOutput:=True;

end;

procedure CancelOutput;

var

 Nombre_Fichero: String[4];

begin

 if not OutRedir then Exit;

 Nombre_Fichero:='CON'#0;

 asm

 push ds

 mov ax, ss

 mov ds, ax

 lea dx, Nombre_Fichero[1]

 mov ax, 3D01h

 int 21h

 pop ds

 jnc @@1

 ret

@@1:

 push ax

 mov bx, ax

 mov cx, Output.FileRec.Handle

 mov ah, 46h

 int 21h

 mov ah, 3Eh

 pop bx

 int 21h

 end;

 OutRedir:=False;

end;

end.

Esta unidad nos permitirá redireccionar la salida estándar a cualquier
fichero (en vez de al monitor), dado por la variable «Nombre_Fichero».
Esta variable puede incluso tomar el valor NUL, en cuyo caso no se
producirá ninguna salida, ni a fichero ni a pantalla.

En el programa principal haremos:

SetOutput('NUL');

Exec(....);

CancelOutput;